home *** CD-ROM | disk | FTP | other *** search
/ Developer CD Series 1998 January: Mac OS SDK / Dev.CD Jan 98 SDK1.toast / Development Kits (Disc 1) / Interfaces&Libraries / Universal / Interfaces / PInterfaces / CardServices.p < prev    next >
Encoding:
Text File  |  1997-08-12  |  31.2 KB  |  916 lines  |  [TEXT/MPS ]
  1. {
  2.      File:        CardServices.p
  3.  
  4.      Contains:    The client interface to Card and Socket Services.
  5.  
  6.      Version:    Technology:    System 7.5
  7.                  Release:    Universal Interfaces 3.0.1
  8.  
  9.      Copyright:    © 1994-1997 by Apple Computer, Inc. All rights reserved.
  10.  
  11.      Bugs?:        Please include the the file and version information (from above) with
  12.                  the problem description.  Developers belonging to one of the Apple
  13.                  developer programs can submit bug reports to:
  14.  
  15.                      devsupport@apple.com
  16.  
  17. }
  18. {$IFC UNDEFINED UsingIncludes}
  19. {$SETC UsingIncludes := 0}
  20. {$ENDC}
  21.  
  22. {$IFC NOT UsingIncludes}
  23.  UNIT CardServices;
  24.  INTERFACE
  25. {$ENDC}
  26.  
  27. {$IFC UNDEFINED __CARDSERVICES__}
  28. {$SETC __CARDSERVICES__ := 1}
  29.  
  30. {$I+}
  31. {$SETC CardServicesIncludes := UsingIncludes}
  32. {$SETC UsingIncludes := 1}
  33.  
  34. {$IFC UNDEFINED __TYPES__}
  35. {$I Types.p}
  36. {$ENDC}
  37. {$IFC UNDEFINED __PCCARDTUPLES__}
  38. {$I PCCardTuples.p}
  39. {$ENDC}
  40. {$IFC UNDEFINED __MIXEDMODE__}
  41. {$I MixedMode.p}
  42. {$ENDC}
  43.  
  44.  
  45. {$PUSH}
  46. {$ALIGN MAC68K}
  47. {$LibExport+}
  48.  
  49. {     miscellaneous }
  50.  
  51.  
  52. CONST
  53.     CS_MAX_SOCKETS                = 32;                            {  a long is used as a socket bitmap }
  54.  
  55.  
  56. {  Will move to <Traps.h> }
  57.     _PCCardDispatch                = $AAF0;                        {  Card Services entry trap }
  58.  
  59. {  Will move to <Errors.h> }
  60.  
  61. {     result codes }
  62.  
  63.     kCSBadAdapterErr            = -9050;                        {  invalid adapter number }
  64.     kCSBadAttributeErr            = -9051;                        {  specified attributes field value is invalid }
  65.     kCSBadBaseErr                = -9052;                        {  specified base system memory address is invalid }
  66.     kCSBadEDCErr                = -9053;                        {  specified EDC generator specified is invalid }
  67.     kCSBadIRQErr                = -9054;                        {  specified IRQ level is invalid }
  68.     kCSBadOffsetErr                = -9055;                        {  specified PC card memory array offset is invalid }
  69.     kCSBadPageErr                = -9056;                        {  specified page is invalid }
  70.     kCSBadSizeErr                = -9057;                        {  specified size is invalid }
  71.     kCSBadSocketErr                = -9058;                        {  specified logical or physical socket number is invalid }
  72.     kCSBadTypeErr                = -9059;                        {  specified window or interface type is invalid }
  73.     kCSBadVccErr                = -9060;                        {  specified Vcc power level index is invalid }
  74.     kCSBadVppErr                = -9061;                        {  specified Vpp1 or Vpp2 power level index is invalid }
  75.     kCSBadWindowErr                = -9062;                        {  specified window is invalid }
  76.     kCSBadArgLengthErr            = -9063;                        {  ArgLength argument is invalid }
  77.     kCSBadArgsErr                = -9064;                        {  values in argument packet are invalid }
  78.     kCSBadHandleErr                = -9065;                        {  clientHandle is invalid }
  79.     kCSBadCISErr                = -9066;                        {  CIS on card is invalid }
  80.     kCSBadSpeedErr                = -9067;                        {  specified speed is unavailable }
  81.     kCSReadFailureErr            = -9068;                        {  unable to complete read request }
  82.     kCSWriteFailureErr            = -9069;                        {  unable to complete write request }
  83.     kCSGeneralFailureErr        = -9070;                        {  an undefined error has occurred }
  84.     kCSNoCardErr                = -9071;                        {  no PC card in the socket }
  85.     kCSUnsupportedFunctionErr    = -9072;                        {  function is not supported by this implementation }
  86.     kCSUnsupportedModeErr        = -9073;                        {  mode is not supported }
  87.     kCSBusyErr                    = -9074;                        {  unable to process request at this time - try later }
  88.     kCSWriteProtectedErr        = -9075;                        {  media is write-protected }
  89.     kCSConfigurationLockedErr    = -9076;                        {  a configuration has already been locked }
  90.     kCSInUseErr                    = -9077;                        {  requested resource is being used by a client }
  91.     kCSNoMoreItemsErr            = -9078;                        {  there are no more of the requested item }
  92.     kCSOutOfResourceErr            = -9079;                        {  Card Services has exhausted the resource }
  93.  
  94.  
  95.  
  96. {     messages sent to client's event handler }
  97.  
  98.     kCSNullMessage                = $00;                            {  no messages pending (not sent to clients) }
  99.     kCSCardInsertionMessage        = $01;                            {  card has been inserted into the socket }
  100.     kCSCardRemovalMessage        = $02;                            {  card has been removed from the socket }
  101.     kCSCardLockMessage            = $03;                            {  card is locked into the socket with a mechanical latch }
  102.     kCSCardUnlockMessage        = $04;                            {  card is no longer locked into the socket }
  103.     kCSCardReadyMessage            = $05;                            {  card is ready to be accessed }
  104.     kCSCardResetMessage            = $06;                            {  physical reset has completed }
  105.     kCSInsertionRequestMessage    = $07;                            {  request to insert a card using insertion motor }
  106.     kCSInsertionCompleteMessage    = $08;                            {  insertion motor has finished inserting a card }
  107.     kCSEjectionRequestMessage    = $09;                            {  user or other client is requesting a card ejection }
  108.     kCSEjectionFailedMessage    = $0A;                            {  eject failure due to electrical/mechanical problems }
  109.     kCSPMResumeMessage            = $0B;                            {  power management resume (TBD) }
  110.     kCSPMSuspendMessage            = $0C;                            {  power management suspend (TBD) }
  111.     kCSResetPhysicalMessage        = $0D;                            {  physical reset is about to occur on this card }
  112.     kCSResetRequestMessage        = $0E;                            {  physical reset has been requested by a client }
  113.     kCSResetCompleteMessage        = $0F;                            {  ResetCard() background reset has completed }
  114.     kCSBatteryDeadMessage        = $10;                            {  battery is no longer useable, data will be lost }
  115.     kCSBatteryLowMessage        = $11;                            {  battery is weak and should be replaced }
  116.     kCSWriteProtectMessage        = $12;                            {  card is now write protected }
  117.     kCSWriteEnabledMessage        = $13;                            {  card is now write enabled }
  118.     kCSClientInfoMessage        = $14;                            {  client is to return client information }
  119.     kCSSSUpdatedMessage            = $15;                            {  AddSocketServices/ReplaceSocket services has changed SS support }
  120.     kCSFunctionInterruptMessage    = $16;                            {  card function interrupt }
  121.     kCSAccessErrorMessage        = $17;                            {  client bus errored on access to socket }
  122.     kCSCardUnconfiguredMessage    = $18;                            {  a CARD_READY was delivered to all clients and no client  }
  123.                                                                 {     requested a configuration for the socket }
  124.     kCSStatusChangedMessage        = $19;                            {  status change for cards in I/O mode }
  125.  
  126. {
  127.     The following is a mapping of the PCMCIA name space to the Macintosh name space.
  128.     These two enum lists will be removed and given to developers as a separate file.
  129. }
  130.     SUCCESS                        = 0;
  131.     BAD_ADAPTER                    = -9050;
  132.     BAD_ATTRIBUTE                = -9051;
  133.     BAD_BASE                    = -9052;
  134.     BAD_EDC                        = -9053;
  135.     BAD_IRQ                        = -9054;
  136.     BAD_OFFSET                    = -9055;
  137.     BAD_PAGE                    = -9056;
  138.     BAD_SIZE                    = -9057;
  139.     BAD_SOCKET                    = -9058;
  140.     BAD_TYPE                    = -9059;
  141.     BAD_VCC                        = -9060;
  142.     BAD_VPP                        = -9061;
  143.     BAD_WINDOW                    = -9062;
  144.     BAD_ARG_LENGTH                = -9063;
  145.     BAD_ARGS                    = -9064;
  146.     BAD_HANDLE                    = -9065;
  147.     BAD_CIS                        = -9066;
  148.     BAD_SPEED                    = -9067;
  149.     READ_FAILURE                = -9068;
  150.     WRITE_FAILURE                = -9069;
  151.     GENERAL_FAILURE                = -9070;
  152.     NO_CARD                        = -9071;
  153.     UNSUPPORTED_FUNCTION        = -9072;
  154.     UNSUPPORTED_MODE            = -9073;
  155.     BUSY                        = -9074;
  156.     WRITE_PROTECTED                = -9075;
  157.     CONFIGURATION_LOCKED        = -9076;
  158.     IN_USE                        = -9077;
  159.     NO_MORE_ITEMS                = -9078;
  160.     OUT_OF_RESOURCE                = -9079;
  161.  
  162.  
  163. {     messages sent to client's event handler }
  164.  
  165.     NULL_MESSAGE                = $00;
  166.     CARD_INSERTION                = $01;
  167.     CARD_REMOVAL                = $02;
  168.     CARD_LOCK                    = $03;
  169.     CARD_UNLOCK                    = $04;
  170.     CARD_READY                    = $05;
  171.     CARD_RESET                    = $06;
  172.     INSERTION_REQUEST            = $07;
  173.     INSERTION_COMPLETE            = $08;
  174.     EJECTION_REQUEST            = $09;
  175.     EJECTION_FAILED                = $0A;
  176.     PM_RESUME                    = $0B;
  177.     PM_SUSPEND                    = $0C;
  178.     RESET_PHYSICAL                = $0D;
  179.     RESET_REQUEST                = $0E;
  180.     RESET_COMPLETE                = $0F;
  181.     BATTERY_DEAD                = $10;
  182.     BATTERY_LOW                    = $11;
  183.     WRITE_PROTECT                = $12;
  184.     WRITE_ENABLED                = $13;
  185.     CLIENT_INFO                    = $14;
  186.     SS_UPDATED                    = $15;
  187.     FUNCTION_INTERRUPT            = $16;
  188.     ACCESS_ERROR                = $17;
  189.     CARD_UNCONFIGURED            = $18;
  190.     STATUS_CHANGED                = $19;
  191.  
  192.  
  193. { ----------------        CSAccessConfigurationRegister    ---------------- }
  194.  
  195.  
  196. TYPE
  197.     AccessConfigurationRegisterPBPtr = ^AccessConfigurationRegisterPB;
  198.     AccessConfigurationRegisterPB = RECORD
  199.         socket:                    UInt16;                                    {   -> global socket number }
  200.         action:                    SInt8;                                    {   -> read/write }
  201.         offset:                    SInt8;                                    {   -> offset from config register base }
  202.         value:                    SInt8;                                    {  <-> value to read/write }
  203.         padding:                SInt8;                                    {   }
  204.     END;
  205.  
  206. {     ‘action’ field values }
  207.  
  208.  
  209. CONST
  210.     kCSReadConfigRegister        = $00;
  211.     kCSWriteConfigRegister        = $01;
  212.  
  213.  
  214. { ----------------        CSGetCardServicesInfo            ---------------- }
  215.  
  216.  
  217. TYPE
  218.     GetCardServicesInfoPBPtr = ^GetCardServicesInfoPB;
  219.     GetCardServicesInfoPB = RECORD
  220.         signature:                PACKED ARRAY [0..1] OF UInt8;            {  <-  two ascii chars 'CS' }
  221.         count:                    UInt16;                                    {  <-  total number of sockets installed }
  222.         revision:                UInt16;                                    {  <-  BCD }
  223.         csLevel:                UInt16;                                    {  <-  BCD }
  224.         reserved:                UInt16;                                    {   -> zero }
  225.         vStrLen:                UInt16;                                    {  <-> in: client's buffer size, out: vendor string length }
  226.         vendorString:            Ptr;                                    {  <-> in: pointer to buffer to hold CS vendor string (zero-terminated) }
  227.                                                                         {       out: CS vendor string copied to buffer }
  228.     END;
  229.  
  230. { ----------------        CSGetClientInfo                    ---------------- }
  231.  
  232.  
  233. {  upper byte of attributes is kCSClientInfoSubfunction }
  234.     ClientInfoParamPtr = ^ClientInfoParam;
  235.     ClientInfoParam = RECORD
  236.         clientHandle:            UInt32;                                    {   -> clientHandle returned by RegisterClient }
  237.         attributes:                UInt16;                                    {  <-> subfunction + bitmapped client attributes }
  238.         revision:                UInt16;                                    {  <-  BCD value of client's revision }
  239.         csLevel:                UInt16;                                    {  <-  BCD value of CS release }
  240.         revDate:                UInt16;                                    {  <-  revision date: y[15-9], m[8-5], d[4-0] }
  241.         nameLen:                SInt16;                                    {  <-> in: max length of client name string, out: actual length }
  242.         vStringLen:                SInt16;                                    {  <-> in: max length of vendor string, out: actual length }
  243.         nameString:                Ptr;                                    {  <-  pointer to client name string (zero-terminated) }
  244.         vendorString:            Ptr;                                    {  <-  pointer to vendor string (zero-terminated) }
  245.     END;
  246.  
  247. {
  248.    upper byte of attributes is kCSCardNameSubfunction,
  249.                                  kCSCardTypeSubfunction,
  250.                                  kCSHelpStringSubfunction
  251. }
  252.     AlternateTextStringParamPtr = ^AlternateTextStringParam;
  253.     AlternateTextStringParam = RECORD
  254.         clientHandle:            UInt32;                                    {   -> clientHandle returned by RegisterClient }
  255.         attributes:                UInt16;                                    {  <-> subfunction + bitmapped client attributes }
  256.         socket:                    UInt16;                                    {   -> logical socket number }
  257.         reserved:                UInt16;                                    {   -> zero }
  258.         length:                    SInt16;                                    {  <-> in: max length of string, out: actual length }
  259.         text:                    Ptr;                                    {  <-  pointer to string (zero-terminated) }
  260.     END;
  261.  
  262. {  upper byte of attributes is kCSCardIconSubfunction }
  263.     AlternateCardIconParamPtr = ^AlternateCardIconParam;
  264.     AlternateCardIconParam = RECORD
  265.         clientHandle:            UInt32;                                    {   -> clientHandle returned by RegisterClient }
  266.         attributes:                UInt16;                                    {  <-> subfunction + bitmapped client attributes }
  267.         socket:                    UInt16;                                    {   -> logical socket number }
  268.         iconSuite:                Handle;                                    {  <-  handle to icon suite containing all icons }
  269.     END;
  270.  
  271. {  upper byte of attributes is kCSActionProcSubfunction }
  272.     CustomActionProcParamPtr = ^CustomActionProcParam;
  273.     CustomActionProcParam = RECORD
  274.         clientHandle:            UInt32;                                    {   -> clientHandle returned by RegisterClient }
  275.         attributes:                UInt16;                                    {  <-> subfunction + bitmapped client attributes }
  276.         socket:                    UInt16;                                    {   -> logical socket number }
  277.     END;
  278.  
  279.     GetClientInfoPBPtr = ^GetClientInfoPB;
  280.     GetClientInfoPB = RECORD
  281.         CASE INTEGER OF
  282.         0: (
  283.             clientInfo:            ClientInfoParam;
  284.             );
  285.         1: (
  286.             alternateTextString: AlternateTextStringParam;
  287.             );
  288.         2: (
  289.             alternateIcon:        AlternateCardIconParam;
  290.             );
  291.         3: (
  292.             customActionProc:    CustomActionProcParam;
  293.             );
  294.     END;
  295.  
  296. {     ‘attributes’ field values }
  297.  
  298. CONST
  299.     kCSMemoryClient                = $0001;
  300.     kCSIOClient                    = $0004;
  301.     kCSClientTypeMask            = $0007;
  302.     kCSShareableCardInsertEvents = $0008;
  303.     kCSExclusiveCardInsertEvents = $0010;
  304.     kCSInfoSubfunctionMask        = $FF00;
  305.     kCSClientInfoSubfunction    = $0000;
  306.     kCSCardNameSubfunction        = $8000;
  307.     kCSCardTypeSubfunction        = $8100;
  308.     kCSHelpStringSubfunction    = $8200;
  309.     kCSCardIconSubfunction        = $8300;
  310.     kCSActionProcSubfunction    = $8400;
  311.  
  312.  
  313. {
  314.   ----------------        CSGetConfigurationInfo            ----------------
  315.   ----------------        CSModifyConfiguration            ----------------
  316.   ----------------        CSRequestConfiguration            ----------------
  317. }
  318.  
  319.  
  320. TYPE
  321.     GetModRequestConfigInfoPBPtr = ^GetModRequestConfigInfoPB;
  322.     GetModRequestConfigInfoPB = RECORD
  323.         clientHandle:            UInt32;                                    {   -> clientHandle returned by RegisterClient }
  324.         socket:                    UInt16;                                    {   -> logical socket number }
  325.         attributes:                UInt16;                                    {  <-> bitmap of configuration attributes }
  326.         vcc:                    SInt8;                                    {  <-> Vcc setting }
  327.         vpp1:                    SInt8;                                    {  <-> Vpp1 setting }
  328.         vpp2:                    SInt8;                                    {  <-> Vpp2 setting }
  329.         intType:                SInt8;                                    {  <-> interface type (memory or memory+I/O) }
  330.         configBase:                UInt32;                                    {  <-> card base address of configuration registers }
  331.         status:                    SInt8;                                    {  <-> card status register setting, if present }
  332.         pin:                    SInt8;                                    {  <-> card pin register setting, if present }
  333.         copy:                    SInt8;                                    {  <-> card socket/copy register setting, if present }
  334.         configIndex:            SInt8;                                    {  <-> card option register setting, if present }
  335.         present:                SInt8;                                    {  <-> bitmap of which configuration registers are present }
  336.         firstDevType:            SInt8;                                    {  <-  from DeviceID tuple }
  337.         funcCode:                SInt8;                                    {  <-  from FuncID tuple }
  338.         sysInitMask:            SInt8;                                    {  <-  from FuncID tuple }
  339.         manufCode:                UInt16;                                    {  <-  from ManufacturerID tuple }
  340.         manufInfo:                UInt16;                                    {  <-  from ManufacturerID tuple }
  341.         cardValues:                SInt8;                                    {  <-  valid card register values }
  342.         padding:                SInt8;                                    {   }
  343.     END;
  344.  
  345. {     ‘attributes’ field values }
  346.  
  347. CONST
  348.     kCSExclusivelyUsed            = $0001;
  349.     kCSEnableIREQs                = $0002;
  350.     kCSVccChangeValid            = $0004;
  351.     kCSVpp1ChangeValid            = $0008;
  352.     kCSVpp2ChangeValid            = $0010;
  353.     kCSValidClient                = $0020;
  354.     kCSSleepPower                = $0040;                        {  request that power be applied to socket during Sleep }
  355.     kCSLockSocket                = $0080;
  356.     kCSTurnOnInUse                = $0100;
  357.  
  358. {     ‘intType’ field values }
  359.  
  360.     kCSMemoryInterface            = $01;
  361.     kCSMemory_And_IO_Interface    = $02;
  362.  
  363. {     ‘present’ field values }
  364.  
  365.     kCSOptionRegisterPresent    = $01;
  366.     kCSStatusRegisterPresent    = $02;
  367.     kCSPinReplacementRegisterPresent = $04;
  368.     kCSCopyRegisterPresent        = $08;
  369.  
  370. {     ‘cardValues’ field values }
  371.  
  372.     kCSOptionValueValid            = $01;
  373.     kCSStatusValueValid            = $02;
  374.     kCSPinReplacementValueValid    = $04;
  375.     kCSCopyValueValid            = $08;
  376.  
  377.  
  378. {
  379.   ----------------        CSGetClientEventMask            ----------------
  380.   ----------------        CSSetClientEventMask            ----------------
  381. }
  382.  
  383.  
  384. TYPE
  385.     GetSetClientEventMaskPBPtr = ^GetSetClientEventMaskPB;
  386.     GetSetClientEventMaskPB = RECORD
  387.         clientHandle:            UInt32;                                    {   -> clientHandle returned by RegisterClient }
  388.         attributes:                UInt16;                                    {  <-> bitmap of attributes }
  389.         eventMask:                UInt16;                                    {  <-> bitmap of events to be passed to client for this socket }
  390.         socket:                    UInt16;                                    {   -> logical socket number }
  391.     END;
  392.  
  393. {     ‘attributes’ field values }
  394.  
  395. CONST
  396.     kCSEventMaskThisSocketOnly    = $0001;
  397.  
  398. {     ‘eventMask’ field values }
  399.  
  400.     kCSWriteProtectEvent        = $0001;
  401.     kCSCardLockChangeEvent        = $0002;
  402.     kCSEjectRequestEvent        = $0004;
  403.     kCSInsertRequestEvent        = $0008;
  404.     kCSBatteryDeadEvent            = $0010;
  405.     kCSBatteryLowEvent            = $0020;
  406.     kCSReadyChangeEvent            = $0040;
  407.     kCSCardDetectChangeEvent    = $0080;
  408.     kCSPMChangeEvent            = $0100;
  409.     kCSResetEvent                = $0200;
  410.     kCSSSUpdateEvent            = $0400;
  411.     kCSFunctionInterrupt        = $0800;
  412.     kCSAllEvents                = $FFFF;
  413.  
  414.  
  415. {
  416.   ----------------        CSGetFirstClient                ----------------
  417.   ----------------        CSGetNextClient                    ----------------
  418. }
  419.  
  420.  
  421. TYPE
  422.     GetClientPBPtr = ^GetClientPB;
  423.     GetClientPB = RECORD
  424.         clientHandle:            UInt32;                                    {  <-  clientHandle for this client }
  425.         socket:                    UInt16;                                    {   -> logical socket number }
  426.         attributes:                UInt16;                                    {   -> bitmap of attributes }
  427.     END;
  428.  
  429. {     ‘attributes’ field values }
  430.  
  431. CONST
  432.     kCSClientsForAllSockets        = $0000;
  433.     kCSClientsThisSocketOnly    = $0001;
  434.  
  435.  
  436. {
  437.   ----------------        CSGetFirstTuple                    ----------------
  438.   ----------------        CSGetNextTuple                    ----------------
  439.   ----------------        CSGetTupleData                    ----------------
  440. }
  441.  
  442.  
  443. TYPE
  444.     GetTuplePBPtr = ^GetTuplePB;
  445.     GetTuplePB = RECORD
  446.         socket:                    UInt16;                                    {   -> logical socket number }
  447.         attributes:                UInt16;                                    {   -> bitmap of attributes }
  448.         desiredTuple:            SInt8;                                    {   -> desired tuple code value, or $FF for all }
  449.         tupleOffset:            SInt8;                                    {   -> offset into tuple from link byte }
  450.         flags:                    UInt16;                                    {  <-> internal use }
  451.         linkOffset:                UInt32;                                    {  <-> internal use }
  452.         cisOffset:                UInt32;                                    {  <-> internal use }
  453.         CASE INTEGER OF
  454.         0: (
  455.             tupleCode:            SInt8;                                    {  <-  tuple code found }
  456.             tupleLink:            SInt8;                                    {  <-  link value for tuple found }
  457.            );
  458.         1: (
  459.             tupleDataMax:        UInt16;                                    {   -> maximum size of tuple data area }
  460.             tupleDataLen:        UInt16;                                    {  <-  number of bytes in tuple body }
  461.             tupleData:            TupleBody;                                {  <-  tuple data }
  462.            );
  463.     END;
  464.  
  465. {     ‘attributes’ field values }
  466.  
  467. CONST
  468.     kCSReturnLinkTuples            = $0001;
  469.  
  470.  
  471. {
  472.   ----------------        CSRequestSocketMask                ----------------
  473.   ----------------        CSReleaseSocketMask                ----------------
  474. }
  475.  
  476.  
  477. TYPE
  478.     ReqRelSocketMaskPBPtr = ^ReqRelSocketMaskPB;
  479.     ReqRelSocketMaskPB = RECORD
  480.         clientHandle:            UInt32;                                    {   -> clientHandle returned by RegisterClient }
  481.         socket:                    UInt16;                                    {   -> logical socket }
  482.         eventMask:                UInt16;                                    {   -> bitmap of events to be passed to client for this socket }
  483.     END;
  484.  
  485. {     ‘eventMask’ field values (see above for Get/SetClientEventMask }
  486.  
  487. { ----------------        CSGetStatus                        ---------------- }
  488.  
  489.     GetStatusPBPtr = ^GetStatusPB;
  490.     GetStatusPB = RECORD
  491.         socket:                    UInt16;                                    {   -> logical socket number }
  492.         cardState:                UInt16;                                    {  <-  current state of installed card }
  493.         socketState:            UInt16;                                    {  <-  current state of the socket }
  494.     END;
  495.  
  496. {     ‘cardState’ field values }
  497.  
  498. CONST
  499.     kCSWriteProtected            = $0001;
  500.     kCSCardLocked                = $0002;
  501.     kCSEjectRequest                = $0004;
  502.     kCSInsertRequest            = $0008;
  503.     kCSBatteryDead                = $0010;
  504.     kCSBatteryLow                = $0020;
  505.     kCSReady                    = $0040;
  506.     kCSCardDetected                = $0080;
  507.  
  508. {     ‘socketState’ field values }
  509.  
  510.     kCSWriteProtectChanged        = $0001;
  511.     kCSCardLockChanged            = $0002;
  512.     kCSEjectRequestPending        = $0004;
  513.     kCSInsertRequestPending        = $0008;
  514.     kCSBatteryDeadChanged        = $0010;
  515.     kCSBatteryLowChanged        = $0020;
  516.     kCSReadyChanged                = $0040;
  517.     kCSCardDetectChanged        = $0080;
  518.  
  519.  
  520. {
  521.   ----------------        CSModifyWindow                    ----------------
  522.   ----------------        CSReleaseWindow                    ----------------
  523.   ----------------        CSRequestWindow                    ----------------
  524. }
  525.  
  526.  
  527. TYPE
  528.     ReqModRelWindowPBPtr = ^ReqModRelWindowPB;
  529.     ReqModRelWindowPB = RECORD
  530.         clientHandle:            UInt32;                                    {   -> clientHandle returned by RegisterClient }
  531.         windowHandle:            UInt32;                                    {  <-> window descriptor }
  532.         socket:                    UInt16;                                    {   -> logical socket number }
  533.         attributes:                UInt16;                                    {   -> window attributes (bitmap) }
  534.         base:                    UInt32;                                    {  <-> system base address }
  535.         size:                    UInt32;                                    {  <-> memory window size }
  536.         accessSpeed:            SInt8;                                    {   -> window access speed (bitmap) }
  537.                                                                         {         (not applicable for I/O mode) }
  538.         padding:                SInt8;                                    {   }
  539.     END;
  540.  
  541. {     ‘attributes’ field values }
  542.  
  543. CONST
  544.     kCSMemoryWindow                = $0001;
  545.     kCSIOWindow                    = $0002;
  546.     kCSAttributeWindow            = $0004;                        {  not normally used by Card Services clients }
  547.     kCSWindowTypeMask            = $0007;
  548.     kCSEnableWindow                = $0008;
  549.     kCSAccessSpeedValid            = $0010;
  550.     kCSLittleEndian                = $0020;                        {  configure socket for little endianess }
  551.     kCS16BitDataPath            = $0040;
  552.     kCSWindowPaged                = $0080;                        {   }
  553.     kCSWindowShared                = $0100;
  554.     kCSWindowFirstShared        = $0200;                        {   }
  555.     kCSWindowProgrammable        = $0400;                        {   }
  556.  
  557. {     ‘accessSpeed’ field values }
  558.  
  559.     kCSDeviceSpeedCodeMask        = $07;
  560.     kCSSpeedExponentMask        = $07;
  561.     kCSSpeedMantissaMask        = $78;
  562.     kCSUseWait                    = $80;
  563.     kCSAccessSpeed250nsec        = $01;
  564.     kCSAccessSpeed200nsec        = $02;
  565.     kCSAccessSpeed150nsec        = $03;
  566.     kCSAccessSpeed100nsec        = $04;
  567.     kCSExtAccSpeedMant1pt0        = $01;
  568.     kCSExtAccSpeedMant1pt2        = $02;
  569.     kCSExtAccSpeedMant1pt3        = $03;
  570.     kCSExtAccSpeedMant1pt5        = $04;
  571.     kCSExtAccSpeedMant2pt0        = $05;
  572.     kCSExtAccSpeedMant2pt5        = $06;
  573.     kCSExtAccSpeedMant3pt0        = $07;
  574.     kCSExtAccSpeedMant3pt5        = $08;
  575.     kCSExtAccSpeedMant4pt0        = $09;
  576.     kCSExtAccSpeedMant4pt5        = $0A;
  577.     kCSExtAccSpeedMant5pt0        = $0B;
  578.     kCSExtAccSpeedMant5pt5        = $0C;
  579.     kCSExtAccSpeedMant6pt0        = $0D;
  580.     kCSExtAccSpeedMant7pt0        = $0E;
  581.     kCSExtAccSpeedMant8pt0        = $0F;
  582.     kCSExtAccSpeedExp1ns        = $00;
  583.     kCSExtAccSpeedExp10ns        = $01;
  584.     kCSExtAccSpeedExp100ns        = $02;
  585.     kCSExtAccSpeedExp1us        = $03;
  586.     kCSExtAccSpeedExp10us        = $04;
  587.     kCSExtAccSpeedExp100us        = $05;
  588.     kCSExtAccSpeedExp1ms        = $06;
  589.     kCSExtAccSpeedExp10ms        = $07;
  590.  
  591.  
  592. {
  593.   ----------------        CSRegisterClient                ----------------
  594.   ----------------        CSDeregisterClient                ----------------
  595. }
  596.  
  597.  
  598. TYPE
  599.     ClientCallbackPBPtr = ^ClientCallbackPB;
  600.     ClientCallbackPB = RECORD
  601.         message:                UInt16;                                    {   -> which event this is }
  602.         socket:                    UInt16;                                    {   -> logical socket number }
  603.         info:                    UInt16;                                    {   -> function-specific }
  604.         misc:                    UInt16;                                    {   -> function-specific }
  605.         reserved:                Ptr;                                    {   -> pointer to MTD request block }
  606.         buffer:                    Ptr;                                    {   -> function-specific }
  607.         clientData:                Ptr;                                    {   -> pointer to client's data (from RegisterClient) }
  608.     END;
  609.  
  610.     PCCardCSClientProcPtr = ProcPtr;  { FUNCTION PCCardCSClient(ccPBPtr: ClientCallbackPBPtr): UInt16; }
  611.  
  612.     PCCardCSClientUPP = UniversalProcPtr;
  613.  
  614. CONST
  615.     uppPCCardCSClientProcInfo = $000000E0;
  616.  
  617. FUNCTION NewPCCardCSClientProc(userRoutine: PCCardCSClientProcPtr): PCCardCSClientUPP;
  618.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  619.     INLINE $2E9F;
  620.     {$ENDC}
  621.  
  622. FUNCTION CallPCCardCSClientProc(ccPBPtr: ClientCallbackPBPtr; userRoutine: PCCardCSClientUPP): UInt16;
  623.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  624.     INLINE $205F, $4E90;
  625.     {$ENDC}
  626.  
  627. TYPE
  628.     RegisterClientPBPtr = ^RegisterClientPB;
  629.     RegisterClientPB = RECORD
  630.         clientHandle:            UInt32;                                    {  <-  client descriptor }
  631.         clientEntry:            PCCardCSClientUPP;                        {   -> universal procPtr to client's event handler }
  632.         attributes:                UInt16;                                    {   -> bitmap of client attributes }
  633.         eventMask:                UInt16;                                    {   -> bitmap of events to notify client }
  634.         clientData:                Ptr;                                    {   -> pointer to client's data }
  635.         version:                UInt16;                                    {   -> Card Services version this client expects }
  636.     END;
  637.  
  638. {     ‘attributes’ field values (see GetClientInfo) }
  639. {
  640.       kCSMemoryClient                    = 0x0001,
  641.       kCSIOClient                        = 0x0004,
  642.       kCSShareableCardInsertEvents    = 0x0008,
  643.       kCSExclusiveCardInsertEvents    = 0x0010
  644. }
  645.  
  646.  
  647. { ----------------        CSReleaseConfiguration            ---------------- }
  648.  
  649.     ReleaseConfigurationPBPtr = ^ReleaseConfigurationPB;
  650.     ReleaseConfigurationPB = RECORD
  651.         clientHandle:            UInt32;                                    {   -> clientHandle returned by RegisterClient }
  652.         socket:                    UInt16;                                    {   ->  }
  653.     END;
  654.  
  655. { ----------------        CSResetCard                        ---------------- }
  656.  
  657.     ResetCardPBPtr = ^ResetCardPB;
  658.     ResetCardPB = RECORD
  659.         clientHandle:            UInt32;                                    {   -> clientHandle returned by RegisterClient }
  660.         socket:                    UInt16;                                    {   ->  }
  661.         attributes:                UInt16;                                    {   -> xxx }
  662.     END;
  663.  
  664. { ----------------        CSValidateCIS                    ---------------- }
  665.  
  666.     ValidateCISPBPtr = ^ValidateCISPB;
  667.     ValidateCISPB = RECORD
  668.         socket:                    UInt16;                                    {   ->  }
  669.         chains:                    UInt16;                                    {   -> whether link/null tuples should be included }
  670.     END;
  671.  
  672. {
  673.   ----------------        CSRequestIO                        ----------------
  674.   ----------------        CSReleaseIO                        ----------------
  675. }
  676.  
  677.     ReqRelIOPBPtr = ^ReqRelIOPB;
  678.     ReqRelIOPB = RECORD
  679.         clientHandle:            UInt32;                                    {   -> clientHandle returned by RegisterClient }
  680.         socket:                    UInt16;                                    {   -> socket number }
  681.         reserved:                UInt16;
  682.         basePort1:                UInt16;                                    {     ->    base I/O port for range }
  683.         numPorts1:                SInt8;                                    {     ->    number of ports (e.g., bytes). }
  684.         attributes1:            SInt8;                                    {     ->    attributes }
  685.         basePort2:                UInt16;                                    {     ->    base I/O port for range }
  686.         numPorts2:                SInt8;                                    {     ->    number of ports }
  687.         attributes2:            SInt8;                                    {     ->    attributes }
  688.         ioAddrLines:            SInt8;                                    {     -> number of I/O lines decoded by card }
  689.         reserved1:                SInt8;
  690.     END;
  691.  
  692. { ----------------        CSVendorSpecific                ---------------- }
  693.     VendorSpecificPBPtr = ^VendorSpecificPB;
  694.     VendorSpecificPB = RECORD
  695.         clientHandle:            UInt32;                                    {   -> clientHandle returned by RegisterClient }
  696.         vsCode:                    UInt16;
  697.         socket:                    UInt16;
  698.         dataLen:                UInt32;                                    {   -> length of buffer pointed to by vsDataPtr }
  699.         vsDataPtr:                Ptr;                                    {   -> Card Services version this client expects }
  700.     END;
  701.  
  702. {     ‘vsCode’ field values }
  703.  
  704.  
  705. CONST
  706.     vsAppleReserved                = $0000;
  707.     vsEjectCard                    = $0001;
  708.     vsGetCardInfo                = $0002;
  709.     vsEnableSocketEvents        = $0003;
  710.     vsGetCardLocationIcon        = $0004;
  711.     vsGetCardLocationText        = $0005;
  712.     vsGetAdapterInfo            = $0006;
  713.  
  714. {
  715.   ///////////////////////////////////////////////////////////////////////////////////////
  716.       GetAdapterInfo parameter block (vendor-specific call #6)
  717. }
  718.  
  719.  
  720. TYPE
  721.     GetAdapterInfoPBPtr = ^GetAdapterInfoPB;
  722.     GetAdapterInfoPB = RECORD
  723.         attributes:                UInt32;                                    {  <-  capabilties of socket's adapter }
  724.         revision:                UInt16;                                    {  <-  id of adapter }
  725.         reserved:                UInt16;                                    {   }
  726.         numVoltEntries:            UInt16;                                    {  <-  number of valid voltage values }
  727.         voltages:                Ptr;                                    {  <-> array of BCD voltage values }
  728.     END;
  729.  
  730. {     ‘attributes’ field values }
  731.  
  732. CONST
  733.     kCSLevelModeInterrupts        = $00000001;
  734.     kCSPulseModeInterrupts        = $00000002;
  735.     kCSProgrammableWindowAddr    = $00000004;
  736.     kCSProgrammableWindowSize    = $00000008;
  737.     kCSSocketSleepPower            = $00000010;
  738.     kCSSoftwareEject            = $00000020;
  739.     kCSLockableSocket            = $00000040;
  740.     kCSInUseIndicator            = $00000080;
  741.  
  742. {
  743.   ///////////////////////////////////////////////////////////////////////////////////////
  744.       GetCardInfo parameter block (vendor-specific call #2)
  745. }
  746.  
  747.  
  748. TYPE
  749.     GetCardInfoPBPtr = ^GetCardInfoPB;
  750.     GetCardInfoPB = RECORD
  751.         cardType:                SInt8;                                    {  <-  type of card in this socket (defined at top of file) }
  752.         subType:                SInt8;                                    {  <-  more detailed card type (defined at top of file) }
  753.         reserved:                UInt16;                                    {  <-> reserved (should be set to zero) }
  754.         cardNameLen:            UInt16;                                    {   -> maximum length of card name to be returned }
  755.         vendorNameLen:            UInt16;                                    {   -> maximum length of vendor name to be returned }
  756.         cardName:                Ptr;                                    {   -> pointer to card name string (read from CIS), or nil }
  757.         vendorName:                Ptr;                                    {   -> pointer to vendor name string (read from CIS), or nil }
  758.     END;
  759.  
  760. {     GetCardInfo card types }
  761.  
  762. CONST
  763.     kCSUnknownCardType            = 0;
  764.     kCSMultiFunctionCardType    = 1;
  765.     kCSMemoryCardType            = 2;
  766.     kCSSerialPortCardType        = 3;
  767.     kCSSerialOnlyType            = 0;
  768.     kCSDataModemType            = 1;
  769.     kCSFaxModemType                = 2;
  770.     kCSFaxAndDataModemMask        = 3;
  771.     kCSVoiceEncodingType        = 4;
  772.     kCSParallelPortCardType        = 4;
  773.     kCSFixedDiskCardType        = 5;
  774.     kCSUnknownFixedDiskType        = 0;
  775.     kCSATAInterface                = 1;
  776.     kCSRotatingDevice            = $00;
  777.     kCSSiliconDevice            = $80;
  778.     kCSVideoAdaptorCardType        = 6;
  779.     kCSNetworkAdaptorCardType    = 7;
  780.     kCSAIMSCardType                = 8;
  781.     kCSNumCardTypes                = 9;
  782.  
  783.  
  784. {$IFC UNDEFINED __PCCARDENABLERPLUGIN__ }
  785. {
  786.     NOTE: These prototypes conflict with PCCardEnablerPlugin.≈
  787.           You cannot use both PCCardEnablerPlugin.h and CardServices.h
  788.           
  789. }
  790. FUNCTION CSVendorSpecific(VAR pb: VendorSpecificPB): OSErr;
  791.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  792.     INLINE $7000, $AAF0;
  793.     {$ENDC}
  794. FUNCTION CSRegisterClient(VAR pb: RegisterClientPB): OSErr;
  795.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  796.     INLINE $7001, $AAF0;
  797.     {$ENDC}
  798. FUNCTION CSDeregisterClient(VAR pb: RegisterClientPB): OSErr;
  799.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  800.     INLINE $7002, $AAF0;
  801.     {$ENDC}
  802. FUNCTION CSGetFirstTuple(VAR pb: GetTuplePB): OSErr;
  803.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  804.     INLINE $7003, $AAF0;
  805.     {$ENDC}
  806. FUNCTION CSGetNextTuple(VAR pb: GetTuplePB): OSErr;
  807.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  808.     INLINE $7004, $AAF0;
  809.     {$ENDC}
  810. FUNCTION CSGetTupleData(VAR pb: GetTuplePB): OSErr;
  811.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  812.     INLINE $7005, $AAF0;
  813.     {$ENDC}
  814. FUNCTION CSGetConfigurationInfo(VAR pb: GetModRequestConfigInfoPB): OSErr;
  815.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  816.     INLINE $7006, $AAF0;
  817.     {$ENDC}
  818. FUNCTION CSGetCardServicesInfo(VAR pb: GetCardServicesInfoPB): OSErr;
  819.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  820.     INLINE $7007, $AAF0;
  821.     {$ENDC}
  822. FUNCTION CSGetStatus(VAR pb: GetStatusPB): OSErr;
  823.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  824.     INLINE $7008, $AAF0;
  825.     {$ENDC}
  826. FUNCTION CSValidateCIS(VAR pb: ValidateCISPB): OSErr;
  827.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  828.     INLINE $7009, $AAF0;
  829.     {$ENDC}
  830. FUNCTION CSGetFirstClient(VAR pb: GetClientPB): OSErr;
  831.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  832.     INLINE $700F, $AAF0;
  833.     {$ENDC}
  834. FUNCTION CSGetNextClient(VAR pb: GetClientPB): OSErr;
  835.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  836.     INLINE $7010, $AAF0;
  837.     {$ENDC}
  838. FUNCTION CSGetClientInfo(VAR pb: GetClientInfoPB): OSErr;
  839.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  840.     INLINE $7011, $AAF0;
  841.     {$ENDC}
  842. FUNCTION CSResetCard(VAR pb: ResetCardPB): OSErr;
  843.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  844.     INLINE $7012, $AAF0;
  845.     {$ENDC}
  846. FUNCTION CSRequestWindow(VAR pb: ReqModRelWindowPB): OSErr;
  847.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  848.     INLINE $7013, $AAF0;
  849.     {$ENDC}
  850. FUNCTION CSModifyWindow(VAR pb: ReqModRelWindowPB): OSErr;
  851.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  852.     INLINE $7014, $AAF0;
  853.     {$ENDC}
  854. FUNCTION CSReleaseWindow(VAR pb: ReqModRelWindowPB): OSErr;
  855.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  856.     INLINE $7015, $AAF0;
  857.     {$ENDC}
  858. FUNCTION CSRequestConfiguration(VAR pb: GetModRequestConfigInfoPB): OSErr;
  859.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  860.     INLINE $701B, $AAF0;
  861.     {$ENDC}
  862. FUNCTION CSModifyConfiguration(VAR pb: GetModRequestConfigInfoPB): OSErr;
  863.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  864.     INLINE $701C, $AAF0;
  865.     {$ENDC}
  866. FUNCTION CSAccessConfigurationRegister(VAR pb: AccessConfigurationRegisterPB): OSErr;
  867.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  868.     INLINE $701D, $AAF0;
  869.     {$ENDC}
  870. FUNCTION CSReleaseConfiguration(VAR pb: ReleaseConfigurationPB): OSErr;
  871.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  872.     INLINE $701E, $AAF0;
  873.     {$ENDC}
  874. FUNCTION CSGetClientEventMask(VAR pb: GetSetClientEventMaskPB): OSErr;
  875.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  876.     INLINE $701F, $AAF0;
  877.     {$ENDC}
  878. FUNCTION CSSetClientEventMask(VAR pb: GetSetClientEventMaskPB): OSErr;
  879.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  880.     INLINE $7020, $AAF0;
  881.     {$ENDC}
  882. FUNCTION CSRequestSocketMask(VAR pb: ReqRelSocketMaskPB): OSErr;
  883.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  884.     INLINE $7021, $AAF0;
  885.     {$ENDC}
  886. FUNCTION CSReleaseSocketMask(VAR pb: ReqRelSocketMaskPB): OSErr;
  887.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  888.     INLINE $7022, $AAF0;
  889.     {$ENDC}
  890.  
  891. {
  892.       Additional calls which are required for all I/O clients when running on
  893.       systems which do not reserve dedicated I/O-spaces for each PC Card.
  894. }
  895.  
  896. FUNCTION CSRequestIO(VAR pb: ReqRelIOPB): OSErr;
  897.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  898.     INLINE $7025, $AAF0;
  899.     {$ENDC}
  900. FUNCTION CSReleaseIO(VAR pb: ReqRelIOPB): OSErr;
  901.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  902.     INLINE $7026, $AAF0;
  903.     {$ENDC}
  904. {$ENDC}
  905.  
  906. {$ALIGN RESET}
  907. {$POP}
  908.  
  909. {$SETC UsingIncludes := CardServicesIncludes}
  910.  
  911. {$ENDC} {__CARDSERVICES__}
  912.  
  913. {$IFC NOT UsingIncludes}
  914.  END.
  915. {$ENDC}
  916.